#pragma once
#include "lexer.h"
#include<iostream>
#include<vector>
#include<string>
#include<memory>

using namespace std;

// 语法树节点基类，多态实现不同节点
struct ASTNode
{
    virtual ~ASTNode() = default;
    virtual void print(int depth = 0)const = 0;
};

// 表达式节点
struct ExprNode : public ASTNode
{
    string op;//存储运算符
    vector<unique_ptr<ASTNode>> children;

    ExprNode(const string& o) : op(o) {}

    void print(int depth)const override {
        cout << string(depth * 4, ' ') << "Expr: " << op << endl;
        for (const auto& child : children) {
            child->print(depth + 1);
        }
    }
};

// 语句节点
struct StmtNode : public ASTNode
{
    string type;//存储 if while 等
    vector<unique_ptr<ASTNode>>children;

    StmtNode(const string& t) :type(t) {}

    void print(int depth)const override {
        cout << string(depth * 4, ' ') << "Stmt: " << type << endl;
        for (const auto& child : children) {
            child->print(depth + 1);
        }
    }
};

// 函数定义节点
struct FuncDefNode : public ASTNode
{
    string retType;//int 或者 void
    string name;
    vector<unique_ptr<ASTNode>>params;//形参节点
    unique_ptr<ASTNode> body;//函数体（语句块）

    FuncDefNode(const string& rt, const string& n) :retType(rt), name(n) {}

    void print(int depth)const override {
        cout << string(depth * 4, ' ') << "FuncDef: " << retType << " " << name << endl;
        for (const auto& param : params) {
            param->print(depth + 1);
        }
        body->print(depth + 1);
    }
};

struct NumberNode : public ASTNode
{
    string value;
    bool isFloat;
    string type = isFloat ? "float" : "int";

    NumberNode(const string& val, bool isF) : value(val), isFloat(isF) {}

    void print(int depth)const override {
        cout << string(depth * 4, ' ') << "Number: " << type << " " << value << endl;
    }
};

// 编译单元节点（根节点）
struct CompUnitNode : public ASTNode
{
    vector<unique_ptr<ASTNode>> funcs;

    void print(int depth)const override {
        cout << string(depth * 4, ' ') << "CompUnit: " << endl;
        for (const auto& func : funcs) {
            func->print(depth + 1);
        }
    }
};

struct Parser {
public:
     vector<Token> tokens;
    size_t pos;  // 修改为 size_t 类型

    // 构造函数 - 调整初始化顺序
    Parser(const vector<Token>& tokens) : tokens(tokens), pos(0) {}
    
    // 简单错误处理
    void error(const string& msg);
    // 匹配并推进指针
    void match(TokenType expected);
    // 基本表达式（PrimaryExpr）->返回ExprNode
    unique_ptr<ASTNode> PrimaryExpr();
    // 一元表达式->返回ExprNode
    unique_ptr<ASTNode> UnaryExpr();
    // 乘除模表达式->返回ExprNode
    unique_ptr<ASTNode> MulExpr();
    // 加减表达式->返回ExprNode
    unique_ptr<ASTNode> AddExpr();
    // 关系表达式->返回ExprNode
    unique_ptr<ASTNode> RelExpr();
    // 逻辑与表达式->返回ExprNode
    unique_ptr<ASTNode> LAndExpr();
    // 逻辑或表达式->返回ExprNode
    unique_ptr<ASTNode> LOrExpr();
    // 表达式->返回ExpeNodde
    unique_ptr<ASTNode> Expr();
    // 形参->返回ExprNode
    unique_ptr<ASTNode> Param();
    // 函数定义->返回FuncDefNode
    unique_ptr<ASTNode> FuncDef();
    // 语句块->返回StmtNode
    unique_ptr<ASTNode> Block();
    // 语句->返回StmtNode
    unique_ptr<ASTNode> Stmt();
    unique_ptr<ASTNode> Stmt3();
    unique_ptr<ASTNode> Stmt4();
    unique_ptr<ASTNode> Stmt5();
    unique_ptr<ASTNode> Stmt6();
    unique_ptr<ASTNode> Stmt7();
    unique_ptr<ASTNode> Stmt10();
    // 编译单元->返回CompUnitNode（根节点）
    unique_ptr<ASTNode> CompUnit();
};